/**
 * 用户管理模块
 */
(function () {
    // 添加CSS样式
    const style = document.createElement('style');
    style.textContent = `
        .disabled-btn {
            opacity: 0.5;
            cursor: not-allowed;
            background-color: #cccccc !important;
            border-color: #999999 !important;
            color: #666666 !important;
        }
        .admin-notice {
            color: #1e88e5;
            font-size: 0.9em;
            font-style: italic;
            display: inline-block;
            padding: 4px 8px;
            border-radius: 4px;
            background-color: #e3f2fd;
        }
    `;
    document.head.appendChild(style);

    // 用户数据
    let userData = [];

    // 角色类型
    const ROLE_TYPES = {
        VIEWER: '查看员',
        OPERATOR: '操作员',
        ADMIN: '管理员'
    };

    // 初始化
    function init() {
        try {
            // 初始化Android接口
            if (typeof initAndroidInterface === 'function') {
                initAndroidInterface('用户管理');
            }
            bindEvents();
            loadUserData();
        } catch (error) {
            console.error('初始化用户管理模块失败:', error);
        }
    }

    // 绑定事件
    function bindEvents() {
        // 添加用户按钮点击事件
        const addUserBtn = document.getElementById('add-user-btn');
        if (addUserBtn) {
            addUserBtn.addEventListener('click', function () {
                showAddUserDialog();
            });
        }

        // 用户搜索事件
        const userSearch = document.getElementById('user-search');
        if (userSearch) {
            userSearch.addEventListener('input', function () {
                searchUser();
            });
        }
    }

    // 搜索用户
    function searchUser() {
        const searchInput = document.getElementById('user-search');
        if (!searchInput) return;
        
        const searchText = searchInput.value.toLowerCase();

        if (!searchText) {
            renderUserList(userData);
            return;
        }

        const filteredUsers = userData.filter(user => {
            const username = user.username.toLowerCase();
            const name = user.name.toLowerCase();
            const lastLogin = user.lastLoginTime ? formatDateTime(user.lastLoginTime).toLowerCase() : '';

            return username.includes(searchText) ||
                name.includes(searchText) ||
                lastLogin.includes(searchText);
        });

        renderUserList(filteredUsers);
    }

    // 加载用户数据
    function loadUserData() {
        const userListElement = document.getElementById('user-list');
        if (!userListElement) return;
        
        // 显示加载中
        userListElement.innerHTML = '<div class="empty-list">正在加载用户列表...</div>';
        
        // 检查是否应该使用模拟数据
        if (typeof shouldUseMockData === 'function' && shouldUseMockData()) {
            loadMockUserData();
            return;
        }
        // 使用callAndroidMethodAsync获取用户列表
        if (typeof callAndroidMethodAsync === 'function') {
            callAndroidMethodAsync('getUserList')
                .then(response => {
                    if (response.success && response.data) {
                        userData = Array.isArray(response.data) ? response.data :
                            (response.data.data ? response.data.data : []);
                        renderUserList(userData);
                    } else {
                        console.error('获取用户列表失败:', response.message);
                        if (typeof showToast === 'function') {
                            showToast(response.message, 'error');
                        }
                    }
                })
                .catch(error => {
                    console.error('获取用户列表异常:', error);
                });
        } else {
            console.error('callAndroidMethodAsync 函数不可用');
            loadMockUserData(); // 回退到模拟数据
        }
    }

    // 加载模拟用户数据（开发测试用）
    function loadMockUserData() {
        console.log('使用模拟用户数据');
        if (window.MockUserData && typeof window.MockUserData.getAllUsers === 'function') {
            userData = window.MockUserData.getAllUsers();
            renderUserList(userData);
        } else {
            console.error('MockUserData 未定义或 getAllUsers 方法不可用');
            // 使用空数组作为备用
            userData = [];
            renderUserList(userData);
        }
    }

    // 渲染用户列表
    function renderUserList(users) {
        const userListElement = document.getElementById('user-list');
        if (!userListElement) return;

        userListElement.innerHTML = '';

        if (!users || users.length === 0) {
            userListElement.innerHTML = '<div class="empty-list">暂无用户数据</div>';
            return;
        }

        // 创建表格
        const tableHTML = `
            <table class="device-table">
                <thead>
                    <tr>
                        <th>序号</th>
                        <th>用户名</th>
                        <th>姓名</th>
                        <th>角色</th>
                        <th>最后登录时间</th>
                        <th>操作</th>
                    </tr>
                </thead>
                <tbody>
                    ${users.map((user, index) => {
            const roleText = ROLE_TYPES[user.role] || user.role;
            // 格式化最后登录时间，如果没有则显示"--"
            const lastLoginTime = user.lastLoginTime ? formatDateTime(user.lastLoginTime) : '--';

            // 判断是否为管理员，如果是则不显示编辑和删除按钮
            const isAdmin = user.role === 'ADMIN';
            // 为非管理员用户生成操作按钮，管理员用户不显示任何内容
            const actionButtons = isAdmin ?
                '' :
                `<button class="btn-edit" data-id="${user.id}">编辑</button>
                 <button class="btn-delete" data-id="${user.id}">删除</button>`;

            return `
                            <tr data-id="${user.id}">
                                <td>${index + 1}</td>
                                <td>${user.username}</td>
                                <td>${user.name}</td>
                                <td>${roleText}</td>
                                <td>${lastLoginTime}</td>
                                <td>
                                    ${actionButtons}
                                </td>
                            </tr>
                        `;
        }).join('')}
                </tbody>
            </table>
        `;

        userListElement.innerHTML = tableHTML;

        // 绑定编辑和删除按钮事件
        bindTableEvents();
    }

    // 格式化日期时间
    function formatDateTime(timestamp) {
        if (!timestamp) return '--';

        const date = new Date(timestamp);
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hours = String(date.getHours()).padStart(2, '0');
        const minutes = String(date.getMinutes()).padStart(2, '0');

        return `${year}-${month}-${day} ${hours}:${minutes}`;
    }

    // 绑定表格中的按钮事件
    function bindTableEvents() {
        // 编辑按钮点击事件
        document.querySelectorAll('.btn-edit').forEach(button => {
            button.addEventListener('click', function (e) {
                e.stopPropagation();
                const userId = this.getAttribute('data-id');
                const user = userData.find(u => u.id == userId);
                // 检查用户是否为管理员，如果是则不允许编辑
                if (user && user.role === 'ADMIN') {
                    showInfoDialog('管理员用户不可编辑', 'warning');
                    return;
                }
                if (user) {
                    showEditUserDialog(user);
                }
            });
        });

        // 删除按钮点击事件
        document.querySelectorAll('.btn-delete').forEach(button => {
            button.addEventListener('click', function (e) {
                e.stopPropagation();
                const userId = this.getAttribute('data-id');
                const user = userData.find(u => u.id == userId);
                // 检查用户是否为管理员，如果是则不允许删除
                if (user && user.role === 'ADMIN') {
                    showInfoDialog('管理员用户不可删除', 'warning');
                    return;
                }
                showDeleteUserConfirm(userId);
            });
        });
    }

    // 显示添加用户对话框
    function showAddUserDialog() {
        // 获取当前主题
        const currentTheme = document.documentElement.getAttribute('data-theme') || 'default';

        // 使用通用表单模态框
        const modal = showFormModal({
            title: '添加用户',
            fields: getUserFormFields(),
            submitText: '添加',
            cancelText: '取消',
            layout: 'double', // 使用双列布局
            closable: true,  // 允许通过右上角X关闭
            closeOnBackdropClick: false, // 禁止点击背景关闭对话框
            onSubmit: function (formData) {
                console.log("表单提交回调被触发", formData);

                // 表单验证
                if (!formData.username || !formData.name || !formData.password) {
                    showInfoDialog('请填写完整的用户信息', 'warning');
                    return;
                }

                // 检查用户名是否已存在
                const existingUser = userData.find(u => u.username === formData.username);
                if (existingUser) {
                    showInfoDialog('用户名已存在', 'warning');
                    return;
                }

                // 创建新用户
                const newUser = {
                    id: Date.now(), // 临时ID，实际应由后端生成
                    username: formData.username,
                    name: formData.name,
                    password: formData.password,
                    role: formData.role
                };

                if (typeof shouldUseMockData === 'function' && shouldUseMockData()) {
                    // 使用MockUserData添加用户
                    const result = window.MockUserData.addUser(newUser);
                    if (result.success) {
                        // 刷新数据
                        userData = window.MockUserData.getAllUsers();
                        renderUserList(userData);
                        closeModal();
                    } else {
                        showInfoDialog(result.message || '添加用户失败', 'error');
                    }
                    return;
                }

                callAndroidMethodAsync('addUser', newUser)
                    .then(response => {
                        if (response.success) {
                            userData.push(newUser);
                            renderUserList(userData);
                            closeModal();
                        } else {
                            showInfoDialog('添加用户失败: ' + (response.message || '未知错误'), 'error');
                        }
                    })
                    .catch(error => {
                        console.error('添加用户异常:', error);
                        showInfoDialog('添加用户失败: ' + error.message, 'error');
                    });
            }
        });

        // 确保模态框应用当前主题
        if (modal && modal.classList) {
            modal.classList.add(`theme-${currentTheme}`);
        }

        console.log("添加用户模态框已创建");
    }

    // 获取用户表单字段
    function getUserFormFields(userData = {}) {
        return [
            {
                name: 'username',
                label: '用户名',
                type: 'text',
                required: true,
                value: userData.username || '',
                readonly: !!userData.username // 编辑时用户名不可修改
            },
            {
                name: 'name',
                label: '姓名',
                type: 'text',
                required: true,
                value: userData.name || ''
            },
            {
                name: 'password',
                label: '密码',
                type: 'password',
                required: !userData.id, // 新增时必填，编辑时可选
                placeholder: userData.id ? '不修改请留空' : '请输入密码'
            },
            {
                name: 'role',
                label: '角色',
                type: 'select',
                options: [
                    { value: 'VIEWER', text: '查看员' },
                    { value: 'OPERATOR', text: '操作员' }
                ],
                value: userData.role || 'VIEWER'
            }
        ];
    }

    // 显示编辑用户对话框
    function showEditUserDialog(user) {
        // 获取当前主题
        const currentTheme = document.documentElement.getAttribute('data-theme') || 'default';

        // 使用通用表单模态框
        const modal = showFormModal({
            title: '编辑用户',
            fields: getUserFormFields(user),
            submitText: '保存',
            cancelText: '取消',
            layout: 'double', // 使用双列布局
            closable: false,  // 禁止点击背景关闭对话框
            onSubmit: function (formData) {
                console.log("表单提交回调被触发", formData);

                // 表单验证
                if (!formData.name) {
                    showInfoDialog('请填写姓名', 'warning');
                    return;
                }

                // 更新用户信息
                const updatedUser = {
                    ...user,
                    name: formData.name,
                    role: formData.role
                };

                // 如果密码不为空，则更新密码
                if (formData.password) {
                    updatedUser.password = formData.password;
                }

                if (typeof shouldUseMockData === 'function' && shouldUseMockData()) {
                    // 使用MockUserData更新用户
                    const result = window.MockUserData.updateUser(updatedUser);
                    if (result.success) {
                        // 刷新数据
                        userData = window.MockUserData.getAllUsers();
                        renderUserList(userData);
                        closeModal();
                    } else {
                        showInfoDialog(result.message || '更新用户失败', 'error');
                    }
                    return;
                }

                // 调用Android接口更新用户
                callAndroidMethodAsync('updateUser', updatedUser)
                    .then(response => {
                        if (response.success) {
                            // 更新本地数据
                            const index = userData.findIndex(u => u.id == user.id);
                            if (index !== -1) {
                                userData[index] = updatedUser;
                            }
                            renderUserList(userData);
                            closeModal();
                        } else {
                            showInfoDialog('更新用户失败: ' + (response.message || '未知错误'), 'error');
                        }
                    })
                    .catch(error => {
                        console.error('更新用户异常:', error);
                        showInfoDialog('更新用户失败: ' + error.message, 'error');
                    });
            }
        });

        // 确保模态框应用当前主题
        if (modal && modal.classList) {
            modal.classList.add(`theme-${currentTheme}`);
        }

        console.log("编辑用户模态框已创建");
    }

    // 显示删除用户确认对话框
    function showDeleteUserConfirm(userId) {
        // 获取用户信息
        const user = userData.find(u => u.id == userId);
        if (!user) return;

        showConfirmDialog({
            message: `确定要删除用户 "${user.username} (${user.name})" 吗？`,
            onConfirm: function () {
                performDeleteUser(userId);
            }
        });
    }

    // 执行删除用户操作
    function performDeleteUser(userId) {
        // 获取用户信息
        const user = userData.find(u => u.id == userId);
        if (!user) return;

        // 检查用户是否为管理员，如果是则不允许删除
        if (user.role === 'ADMIN') {
            showInfoDialog('管理员用户不可删除', 'warning');
            return;
        }

        if (typeof shouldUseMockData === 'function' && shouldUseMockData()) {
            // 使用MockUserData删除用户
            const result = window.MockUserData.deleteUser(userId);
            if (result.success) {
                // 刷新数据
                userData = window.MockUserData.getAllUsers();
                renderUserList(userData);
            } else {
                showInfoDialog(result.message || '删除用户失败', 'error');
            }
            return;
        }

        callAndroidMethodAsync('deleteUser', { id: userId })
            .then(response => {
                if (response.success) {
                    // 更新本地数据
                    userData = userData.filter(u => u.id != userId);
                    renderUserList(userData);
                } else {
                    showInfoDialog('删除用户失败: ' + (response.message || '未知错误'), 'error');
                }
            })
            .catch(error => {
                console.error('删除用户异常:', error);
                showInfoDialog('删除用户失败: ' + error.message, 'error');
            });
    }

    // ========== 用户登录状态管理 ==========

    /**
     * 获取当前登录用户信息
     * @returns {Object|null} 用户信息对象，如果未登录则返回null
     */
    function getCurrentUser() {
        try {
            const userJson = localStorage.getItem('currentUser');
            if (!userJson) return null;

            return JSON.parse(userJson);
        } catch (e) {
            console.error('获取用户信息失败:', e);
            return null;
        }
    }

    /**
     * 设置当前登录用户信息
     * @param {Object} userData 用户数据对象
     */
    function setCurrentUser(userData) {
        try {
            // 确保密码不会被保存到本地存储
            const userToStore = { ...userData };
            if (userToStore.password) {
                userToStore.password = '******';
            }

            // 添加登录时间
            userToStore.lastLogin = new Date().toISOString();

            localStorage.setItem('currentUser', JSON.stringify(userToStore));
            console.log('用户信息已保存');
            return true;
        } catch (e) {
            console.error('保存用户信息失败:', e);
            return false;
        }
    }

    /**
     * 检查用户是否已登录
     * @returns {boolean} 是否已登录
     */
    function isUserLoggedIn() {
        return getCurrentUser() !== null;
    }

    /**
     * 清除用户登录信息
     */
    function clearUserInfo() {
        localStorage.removeItem('currentUser');
        console.log('用户信息已清除');
    }

    /**
     * 检查用户登录状态，如果未登录则重定向到登录页面
     * @returns {boolean} 是否已登录
     */
    function checkLoginStatus() {
        const loggedIn = isUserLoggedIn();
        console.log("checkLoginStatus", loggedIn);

        if (!loggedIn) {
            console.log('用户未登录，重定向到登录页面');
            window.location.href = '../page/login.html';
        }

        return loggedIn;
    }

    /**
     * 用户退出登录
     * @returns {Promise} 退出登录结果的Promise
     */
    function logout() {
        return new Promise((resolve) => {
            try {
                // 清除本地用户信息
                clearUserInfo();
                resolve(true);
            } catch (error) {
                console.error('退出登录失败:', error);
                // 即使出错，本地也已清除登录信息
                resolve(true);
            }
        });
    }

    // 暴露公共方法到全局
    window.UserManager = {
        logout,
        getCurrentUser,
        setCurrentUser,
        isUserLoggedIn,
        checkLoginStatus,
        clearUserInfo,
        init,
    };

    // 页面加载完成后初始化
    document.addEventListener('DOMContentLoaded', function() {
        init();
    });
})(); 